import { getConfigByKey } from '@/api/config'

// 参数缓存对象
const configCache = {}

/**
 * 设置参数缓存
 * @param {string} key 参数键
 * @param {any} value 参数值
 */
export function setConfigCache(key, value) {
  configCache[key] = value
}

/**
 * 获取参数缓存
 * @param {string} key 参数键
 * @returns {any} 参数值
 */
export function getConfigCache(key) {
  return configCache[key]
}

/**
 * 清除参数缓存
 * @param {string} [key] 参数键，不传则清除所有
 */
export function clearConfigCache(key) {
  if (key) {
    delete configCache[key]
  } else {
    Object.keys(configCache).forEach(k => {
      delete configCache[k]
    })
  }
}

/**
 * 获取系统参数
 * @param {string} key 参数键
 * @param {any} [defaultValue] 默认值，当参数不存在时返回
 * @param {boolean} [useCache=true] 是否使用缓存
 * @returns {Promise<any>} 参数值
 */
export async function getConfig(key, defaultValue = null, useCache = true) {
  if (useCache) {
    // 先从缓存获取
    const cachedValue = getConfigCache(key)
    if (cachedValue !== undefined) {
      return cachedValue
    }
  }
  
  try {
    // 从后端获取
    const res = await getConfigByKey(key)
    if (res.data) {
      // 解析参数值
      let value = res.data.value
      
      // 尝试解析JSON，如果是有效的JSON则转换为对象
      try {
        const parsedValue = JSON.parse(value)
        if (typeof parsedValue === 'object' || Array.isArray(parsedValue)) {
          value = parsedValue
        }
      } catch (e) {
        // 解析失败，保持原值
      }
      
      // 设置缓存
      if (useCache) {
        setConfigCache(key, value)
      }
      
      return value
    }
  } catch (error) {
    console.error(`获取系统参数[${key}]失败:`, error)
  }
  
  return defaultValue
}

/**
 * 批量获取系统参数
 * @param {Array<string>} keys 参数键数组
 * @param {boolean} [useCache=true] 是否使用缓存
 * @returns {Promise<Object>} 参数键值对象
 */
export async function getConfigs(keys, useCache = true) {
  const result = {}
  
  const tasks = keys.map(async key => {
    result[key] = await getConfig(key, null, useCache)
  })
  
  await Promise.all(tasks)
  
  return result
}

/**
 * 解析参数值为特定类型
 * @param {string} value 参数值
 * @param {string} type 类型
 * @returns {any} 转换后的值
 */
export function parseConfigValue(value, type) {
  if (value === null || value === undefined) {
    return null
  }
  
  switch (type) {
    case 'number':
      return Number(value)
    case 'boolean':
      return value === 'true' || value === '1' || value === 1
    case 'json':
      try {
        return JSON.parse(value)
      } catch (e) {
        console.error('JSON解析失败:', e)
        return null
      }
    default:
      return value
  }
} 